<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>TR1 By Subject</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../boost_tr1.html" title="Chapter&#160;29.&#160;Boost.TR1">
<link rel="prev" href="config.html" title="Configuration">
<link rel="next" href="header_list.html" title="TR1 By Header">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
<td align="center"><a href="../../../index.html">Home</a></td>
<td align="center"><a href="../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="config.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../boost_tr1.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="header_list.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="boost_tr1.subject_list"></a><a class="link" href="subject_list.html" title="TR1 By Subject">TR1 By Subject</a>
</h2></div></div></div>
<div class="toc"><dl>
<dt><span class="section"><a href="subject_list.html#boost_tr1.subject_list.ref">Reference Wrappers.</a></span></dt>
<dt><span class="section"><a href="subject_list.html#boost_tr1.subject_list.ptrs">Smart Pointers.</a></span></dt>
<dt><span class="section"><a href="subject_list.html#boost_tr1.subject_list.result_of">Class template result_of.</a></span></dt>
<dt><span class="section"><a href="subject_list.html#boost_tr1.subject_list.mem_fn">Function template mem_fn.</a></span></dt>
<dt><span class="section"><a href="subject_list.html#boost_tr1.subject_list.bind">Function Object Binders.</a></span></dt>
<dt><span class="section"><a href="subject_list.html#boost_tr1.subject_list.function">Polymorphic function
      wrappers.</a></span></dt>
<dt><span class="section"><a href="subject_list.html#boost_tr1.subject_list.type_traits">Type Traits.</a></span></dt>
<dt><span class="section"><a href="subject_list.html#boost_tr1.subject_list.random">Random Number Generators
      and Distributions.</a></span></dt>
<dt><span class="section"><a href="subject_list.html#boost_tr1.subject_list.tuple">Tuples.</a></span></dt>
<dt><span class="section"><a href="subject_list.html#boost_tr1.subject_list.utility">Tuple Interface to std::pair.</a></span></dt>
<dt><span class="section"><a href="subject_list.html#boost_tr1.subject_list.array">Fixed Size Array.</a></span></dt>
<dt><span class="section"><a href="subject_list.html#boost_tr1.subject_list.hash">Hash Function Objects.</a></span></dt>
<dt><span class="section"><a href="subject_list.html#boost_tr1.subject_list.regex">Regular Expressions.</a></span></dt>
<dt><span class="section"><a href="subject_list.html#boost_tr1.subject_list.complex">Complex Number Algorithm
      Overloads.</a></span></dt>
<dt><span class="section"><a href="subject_list.html#boost_tr1.subject_list.complex_trig">Complex Number Additional
      Algorithms.</a></span></dt>
<dt><span class="section"><a href="subject_list.html#boost_tr1.subject_list.unordered_set">Unordered Associative
      Set (Hash Table).</a></span></dt>
<dt><span class="section"><a href="subject_list.html#boost_tr1.subject_list.unordered_map">Unordered Associative
      Map (Hash Table).</a></span></dt>
<dt><span class="section"><a href="subject_list.html#boost_tr1.subject_list.special">Mathematical Special
      Functions.</a></span></dt>
<dt><span class="section"><a href="subject_list.html#boost_tr1.subject_list.c99_special">C99 Mathematical
      Special Functions.</a></span></dt>
</dl></div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_tr1.subject_list.ref"></a><a class="link" href="subject_list.html#boost_tr1.subject_list.ref" title="Reference Wrappers.">Reference Wrappers.</a>
</h3></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">tr1</span><span class="special">/</span><span class="identifier">functional</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
        or
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">functional</span><span class="special">&gt;</span>
</pre>
<p>
        The Ref library is a small library that is useful for passing references
        to function templates (algorithms) that would usually take copies of their
        arguments. It defines the class template <code class="computeroutput"><span class="identifier">reference_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>,
        and the two functions <code class="computeroutput"><span class="identifier">ref</span></code>
        and <code class="computeroutput"><span class="identifier">cref</span></code> that return instances
        of <code class="computeroutput"><span class="identifier">reference_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>.
        <a href="../../../doc/html/ref.html" target="_top">Refer to Boost.Bind for more information.</a>
      </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">tr1</span> <span class="special">{</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">reference_wrapper</span><span class="special">;</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">reference_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">ref</span><span class="special">(</span><span class="identifier">T</span><span class="special">&amp;);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">reference_wrapper</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">cref</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">reference_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">ref</span><span class="special">(</span><span class="identifier">reference_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">reference_wrapper</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">cref</span><span class="special">(</span><span class="identifier">reference_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;);</span>

<span class="special">}</span> <span class="comment">// namespace tr1</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre>
<p>
        <span class="bold"><strong>Configuration:</strong></span> <a href="../../../libs/config/index.html" target="_top">Boost.Config</a>
        should (automatically) define the macro BOOST_HAS_TR1_REFERENCE_WRAPPER if
        your standard library implements this part of TR1.
      </p>
<p>
        <span class="bold"><strong>Standard Conformity:</strong></span> The Boost version of
        this this component does not currently support function call invocation (2.1.2.4),
        or derivation from std::unary_function or std::binary_function (2.1.2 paragraphs
        3 and 4).
      </p>
<p>
        The Boost version is not implicitly convertible to T&amp; as the TR requires.
      </p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_tr1.subject_list.ptrs"></a><a class="link" href="subject_list.html#boost_tr1.subject_list.ptrs" title="Smart Pointers.">Smart Pointers.</a>
</h3></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">tr1</span><span class="special">/</span><span class="identifier">memory</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
        or
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">memory</span><span class="special">&gt;</span>
</pre>
<p>
        The <code class="computeroutput"><span class="identifier">shared_ptr</span></code> class template
        stores a pointer to a dynamically allocated object, typically with a C++
        new-expression. The object pointed to is guaranteed to be deleted when the
        last <code class="computeroutput"><span class="identifier">shared_ptr</span></code> pointing
        to it is destroyed or reset. For more information refer to the <a href="../../../libs/smart_ptr/shared_ptr.htm" target="_top">shared_ptr</a>
        and <a href="../../../libs/smart_ptr/weak_ptr.htm" target="_top">weak_ptr</a> documentation.
      </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">tr1</span> <span class="special">{</span>

<span class="keyword">class</span> <span class="identifier">bad_weak_ptr</span><span class="special">;</span>

<span class="comment">// [2.2.3] Class template shared_ptr</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">shared_ptr</span><span class="special">;</span>

<span class="comment">// [2.2.3.6] shared_ptr comparisons</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;(</span><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>

<span class="comment">// [2.2.3.8] shared_ptr specialized algorithms</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="identifier">b</span><span class="special">);</span>

<span class="comment">// [2.2.3.9] shared_ptr casts</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span> <span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">static_pointer_cast</span><span class="special">(</span><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">r</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span> <span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">dynamic_pointer_cast</span><span class="special">(</span><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">r</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span> <span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">const_pointer_cast</span><span class="special">(</span><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">r</span><span class="special">);</span>

<span class="comment">// [2.2.3.7] shared_ptr I/O</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">E</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Y</span><span class="special">&gt;</span>
<span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">E</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="keyword">operator</span><span class="special">&lt;&lt;</span> <span class="special">(</span><span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">E</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="identifier">os</span><span class="special">,</span> <span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">Y</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">p</span><span class="special">);</span>

<span class="comment">// [2.2.3.10] shared_ptr get_deleter</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">D</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">D</span> <span class="special">*</span> <span class="identifier">get_deleter</span><span class="special">(</span><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">p</span><span class="special">);</span>

<span class="comment">// [2.2.4] Class template weak_ptr</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">weak_ptr</span><span class="special">;</span>

<span class="comment">// [2.2.4.6] weak_ptr comparison</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;(</span><span class="identifier">weak_ptr</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">weak_ptr</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>

<span class="comment">// [2.2.4.7] weak_ptr specialized algorithms</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">weak_ptr</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">weak_ptr</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="identifier">b</span><span class="special">);</span>

<span class="comment">// [2.2.5] Class enable_shared_from_this</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">enable_shared_from_this</span><span class="special">;</span>

<span class="special">}</span> <span class="comment">// namespace tr1</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre>
<p>
        <span class="bold"><strong>Configuration:</strong></span> <a href="../../../libs/config/index.html" target="_top">Boost.Config</a>
        should (automatically) define the macro BOOST_HAS_TR1_SHARED_PTR if your
        standard library implements this part of TR1.
      </p>
<p>
        <span class="bold"><strong>Standard Conformity:</strong></span> There are no known
        deviations from the standard when using the Boost version of this component.
      </p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_tr1.subject_list.result_of"></a><a class="link" href="subject_list.html#boost_tr1.subject_list.result_of" title="Class template result_of.">Class template result_of.</a>
</h3></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">tr1</span><span class="special">/</span><span class="identifier">functional</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
        or
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">functional</span><span class="special">&gt;</span>
</pre>
<p>
        The class template <code class="computeroutput"><span class="identifier">result_of</span></code>
        helps determine the type of a call expression. Given an lvalue <code class="computeroutput"><span class="identifier">f</span></code> of type <code class="computeroutput"><span class="identifier">F</span></code>
        and lvalues <code class="computeroutput"><span class="identifier">t1</span></code>, <code class="computeroutput"><span class="identifier">t2</span><span class="special">,</span> <span class="special">...,</span>
        <span class="identifier">tN</span></code> of types <code class="computeroutput"><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">,</span>
        <span class="special">...,</span> <span class="identifier">TN</span></code>,
        respectively, the type <code class="computeroutput"><span class="identifier">result_of</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">(</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">TN</span><span class="special">)&gt;::</span><span class="identifier">type</span></code>
        defines the result type of the expression <code class="computeroutput"><span class="identifier">f</span><span class="special">(</span><span class="identifier">t1</span><span class="special">,</span>
        <span class="identifier">t2</span><span class="special">,</span> <span class="special">...,</span><span class="identifier">tN</span><span class="special">)</span></code>. The implementation permits the type <code class="computeroutput"><span class="identifier">F</span></code> to be a function pointer, function reference,
        member function pointer, or class type. For more information <a href="../../../libs/utility/utility.htm#result_of" target="_top">refer
        to the Boost.Utility documentation.</a>
      </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">tr1</span> <span class="special">{</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">result_of</span>
<span class="special">{</span>
   <span class="keyword">typedef</span> <span class="identifier">unspecified</span> <span class="identifier">type</span><span class="special">;</span>
<span class="special">};</span>

<span class="special">}</span> <span class="comment">// namespace tr1</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre>
<p>
        <span class="bold"><strong>Configuration:</strong></span> <a href="../../../libs/config/index.html" target="_top">Boost.Config</a>
        should (automatically) define the macro BOOST_HAS_TR1_RESULT_OF if your standard
        library implements this part of TR1.
      </p>
<p>
        <span class="bold"><strong>Standard Conformity:</strong></span> No known problems.
      </p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_tr1.subject_list.mem_fn"></a><a class="link" href="subject_list.html#boost_tr1.subject_list.mem_fn" title="Function template mem_fn.">Function template mem_fn.</a>
</h3></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">tr1</span><span class="special">/</span><span class="identifier">functional</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
        or
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">functional</span><span class="special">&gt;</span>
</pre>
<p>
        <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">tr1</span><span class="special">::</span><span class="identifier">mem_fn</span></code>
        is a generalization of the standard functions <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">mem_fun</span></code>
        and <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">mem_fun_ref</span></code>. It supports member function
        pointers with more than one argument, and the returned function object can
        take a pointer, a reference, or a smart pointer to an object instance as
        its first argument. <code class="computeroutput"><span class="identifier">mem_fn</span></code>
        also supports pointers to data members by treating them as functions taking
        no arguments and returning a (const) reference to the member. For more information
        refer to the <a href="../../../libs/bind/mem_fn.html" target="_top">Boost.Mem_fn documentation</a>.
      </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">tr1</span> <span class="special">{</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">unspecified</span> <span class="identifier">mem_fn</span><span class="special">(</span><span class="identifier">R</span> <span class="identifier">T</span><span class="special">::*</span> <span class="identifier">pm</span><span class="special">);</span>

<span class="special">}</span> <span class="comment">// namespace tr1</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre>
<p>
        <span class="bold"><strong>Configuration:</strong></span> <a href="../../../libs/config/index.html" target="_top">Boost.Config</a>
        should (automatically) define the macro BOOST_HAS_TR1_MEM_FN if your standard
        library implements this part of TR1.
      </p>
<p>
        <span class="bold"><strong>Standard Conformity:</strong></span> The Boost implementation
        does not produce functors that inherit from <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">unary_function</span></code>
        or <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">binary_function</span></code>, nor does it function correctly
        with pointers to volatile member functions (these should be extremely rare
        in practice however).
      </p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_tr1.subject_list.bind"></a><a class="link" href="subject_list.html#boost_tr1.subject_list.bind" title="Function Object Binders.">Function Object Binders.</a>
</h3></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">tr1</span><span class="special">/</span><span class="identifier">functional</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
        or
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">functional</span><span class="special">&gt;</span>
</pre>
<p>
        <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">tr1</span><span class="special">::</span><span class="identifier">bind</span></code>
        is a generalization of the standard functions <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">bind1st</span></code>
        and <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">bind2nd</span></code>. It supports arbitrary function
        objects, functions, function pointers, and member function pointers, and
        is able to bind any argument to a specific value or route input arguments
        into arbitrary positions. <code class="computeroutput"><span class="identifier">bind</span></code>
        does not place any requirements on the function object; in particular, it
        does not need the <code class="computeroutput"><span class="identifier">result_type</span></code>,
        <code class="computeroutput"><span class="identifier">first_argument_type</span></code> and
        <code class="computeroutput"><span class="identifier">second_argument_type</span></code> standard
        typedefs. For more information refer to the <a href="../../../libs/bind/bind.html" target="_top">Boost.Bind
        documentation</a>.
      </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">tr1</span> <span class="special">{</span>

<span class="comment">// [3.6] Function object binders</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_bind_expression</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_placeholder</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">F</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="special">...,</span> <span class="keyword">class</span> <span class="identifier">Tn</span> <span class="special">&gt;</span> <span class="identifier">unspecified</span> <span class="identifier">bind</span><span class="special">(</span><span class="identifier">F</span> <span class="identifier">f</span><span class="special">,</span> <span class="identifier">T1</span> <span class="identifier">t1</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">Tn</span> <span class="identifier">tn</span> <span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">F</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="special">...,</span> <span class="keyword">class</span> <span class="identifier">Tn</span> <span class="special">&gt;</span> <span class="identifier">unspecified</span> <span class="identifier">bind</span><span class="special">(</span><span class="identifier">F</span> <span class="identifier">f</span><span class="special">,</span> <span class="identifier">T1</span> <span class="identifier">t1</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">Tn</span> <span class="identifier">tn</span> <span class="special">);</span>

<span class="keyword">namespace</span> <span class="identifier">placeholders</span> <span class="special">{</span>
   <span class="comment">// M is the implementation-defined number of placeholders</span>
   <span class="keyword">extern</span> <span class="identifier">unspecified</span> <span class="identifier">_1</span><span class="special">;</span>
   <span class="keyword">extern</span> <span class="identifier">unspecified</span> <span class="identifier">_2</span><span class="special">;</span>
   <span class="special">.</span>
   <span class="special">.</span>
   <span class="special">.</span>
   <span class="keyword">extern</span> <span class="identifier">unspecified</span> <span class="identifier">_M</span><span class="special">;</span>
<span class="special">}</span>

<span class="special">}</span> <span class="comment">// namespace tr1</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre>
<p>
        <span class="bold"><strong>Configuration:</strong></span> <a href="../../../libs/config/index.html" target="_top">Boost.Config</a>
        should (automatically) define the macro BOOST_HAS_TR1_BIND if your standard
        library implements this part of TR1.
      </p>
<p>
        <span class="bold"><strong>Standard Conformity:</strong></span> The traits classes
        <code class="computeroutput"><span class="identifier">is_placeholder</span></code> and <code class="computeroutput"><span class="identifier">is_bind_expression</span></code> are not supported by
        the Boost implementation.
      </p>
<p>
        The named return value syntax isn't supported if the object being bound is
        a function pointer, for example:
      </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">tr1</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(&amp;</span><span class="identifier">my_proc</span><span class="special">,</span> <span class="identifier">arg1</span><span class="special">,</span> <span class="identifier">arg2</span> <span class="comment">/* etc */</span><span class="special">);</span> <span class="comment">// works OK.</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">tr1</span><span class="special">::</span><span class="identifier">bind</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;(&amp;</span><span class="identifier">my_proc</span><span class="special">,</span> <span class="identifier">arg1</span><span class="special">,</span> <span class="identifier">arg2</span> <span class="comment">/* etc */</span><span class="special">);</span> <span class="comment">// causes compiler error.</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">tr1</span><span class="special">::</span><span class="identifier">bind</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;(</span><span class="identifier">my_function_object</span><span class="special">,</span> <span class="identifier">arg1</span><span class="special">,</span> <span class="identifier">arg2</span> <span class="comment">/* etc */</span><span class="special">);</span> <span class="comment">// works OK.</span>
</pre>
<p>
        On the other hand, the Boost implementation does work with pointers to overloaded
        functions, and optionally with function pointers with non-standard calling
        conventions.
      </p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_tr1.subject_list.function"></a><a class="link" href="subject_list.html#boost_tr1.subject_list.function" title="Polymorphic function wrappers.">Polymorphic function
      wrappers.</a>
</h3></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">tr1</span><span class="special">/</span><span class="identifier">functional</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
        or
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">functional</span><span class="special">&gt;</span>
</pre>
<p>
        The polymorphic function wrappers are a family of class templates that may
        be used as a generalized callback mechanism. A polymorphic function wrapper
        shares features with function pointers, in that both define a call interface
        (for example a function taking two integer arguments and returning a floating-point
        value) through which some arbitrary code may be called. However a polymorphic
        function wrapper can call any callable object with a compatible call signature,
        this could be a function pointer, or it could be a function object produced
        by std::tr1::bind, or some other mechanism. For more information see the
        <a href="../../../doc/html/function.html" target="_top">Boost.Function documentation</a>.
      </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">tr1</span> <span class="special">{</span>

<span class="comment">// [3.7] polymorphic function wrappers</span>
<span class="keyword">class</span> <span class="identifier">bad_function_call</span><span class="special">;</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Function</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">function</span><span class="special">;</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Function</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">function</span><span class="special">&lt;</span><span class="identifier">Function</span><span class="special">&gt;&amp;,</span> <span class="identifier">function</span><span class="special">&lt;</span><span class="identifier">Function</span><span class="special">&gt;&amp;);</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Function1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Function2</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">function</span><span class="special">&lt;</span><span class="identifier">Function1</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">function</span><span class="special">&lt;</span><span class="identifier">Function2</span><span class="special">&gt;&amp;);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Function1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Function2</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">function</span><span class="special">&lt;</span><span class="identifier">Function1</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">function</span><span class="special">&lt;</span><span class="identifier">Function2</span><span class="special">&gt;&amp;);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Function</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">function</span><span class="special">&lt;</span><span class="identifier">Function</span><span class="special">&gt;&amp;,</span> <span class="identifier">unspecified</span><span class="special">-</span><span class="identifier">null</span><span class="special">-</span><span class="identifier">pointer</span><span class="special">-</span><span class="identifier">type</span> <span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Function</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="identifier">unspecified</span><span class="special">-</span><span class="identifier">null</span><span class="special">-</span><span class="identifier">pointer</span><span class="special">-</span><span class="identifier">type</span> <span class="special">,</span> <span class="keyword">const</span> <span class="identifier">function</span><span class="special">&lt;</span><span class="identifier">Function</span><span class="special">&gt;&amp;);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Function</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">function</span><span class="special">&lt;</span><span class="identifier">Function</span><span class="special">&gt;&amp;,</span> <span class="identifier">unspecified</span><span class="special">-</span><span class="identifier">null</span><span class="special">-</span><span class="identifier">pointer</span><span class="special">-</span><span class="identifier">type</span> <span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Function</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="identifier">unspecified</span><span class="special">-</span><span class="identifier">null</span><span class="special">-</span><span class="identifier">pointer</span><span class="special">-</span><span class="identifier">type</span> <span class="special">,</span> <span class="keyword">const</span> <span class="identifier">function</span><span class="special">&lt;</span><span class="identifier">Function</span><span class="special">&gt;&amp;);</span>

<span class="special">}</span> <span class="comment">// namespace tr1</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre>
<p>
        <span class="bold"><strong>Configuration:</strong></span> <a href="../../../libs/config/index.html" target="_top">Boost.Config</a>
        should (automatically) define the macro BOOST_HAS_TR1_FUNCTION if your standard
        library implements this part of TR1.
      </p>
<p>
        <span class="bold"><strong>Standard Conformity:</strong></span> The Boost version of
        <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">tr1</span><span class="special">::</span><span class="identifier">function</span></code>
        lacks the member function <code class="computeroutput"><span class="identifier">target_type</span><span class="special">()</span></code> and does not inherit from <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">unary_function</span></code>
        or <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">binary_function</span></code> when applicable. The member
        function target() can only access pointer-to-member targets when they have
        been wrapped in mem_fn.
      </p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_tr1.subject_list.type_traits"></a><a class="link" href="subject_list.html#boost_tr1.subject_list.type_traits" title="Type Traits.">Type Traits.</a>
</h3></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">tr1</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
        or
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
</pre>
<p>
        Type traits enable generic code to access the fundamental properties of a
        type, to determine the relationship between two types, or to transform one
        type into another related type. For more information refer to the <a href="../../../libs/type_traits/index.html" target="_top">Boost.Type_traits documentation</a>.
      </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">tr1</span> <span class="special">{</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">v</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">integral_constant</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">integral_constant</span><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span> <span class="keyword">true</span><span class="special">&gt;</span> <span class="identifier">true_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">integral_constant</span><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span> <span class="keyword">false</span><span class="special">&gt;</span> <span class="identifier">false_type</span><span class="special">;</span>

<span class="comment">// [4.5.1] primary type categories:</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_void</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_integral</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_floating_point</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_array</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_pointer</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_reference</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_member_object_pointer</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_member_function_pointer</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_enum</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_union</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_class</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_function</span><span class="special">;</span>

<span class="comment">// [4.5.2] composite type categories:</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_arithmetic</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_fundamental</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_object</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_scalar</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_compound</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_member_pointer</span><span class="special">;</span>

<span class="comment">// [4.5.3] type properties:</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_const</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_volatile</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_pod</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_empty</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_polymorphic</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_abstract</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">has_trivial_constructor</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">has_trivial_copy</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">has_trivial_assign</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">has_trivial_destructor</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">has_nothrow_constructor</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">has_nothrow_copy</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">has_nothrow_assign</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">has_virtual_destructor</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_signed</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_unsigned</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">alignment_of</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">rank</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">I</span> <span class="special">=</span> <span class="number">0</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">extent</span><span class="special">;</span>

<span class="comment">// [4.6] type relations:</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_same</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Base</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Derived</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_base_of</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">From</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">To</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_convertible</span><span class="special">;</span>

<span class="comment">// [4.7.1] const-volatile modifications:</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">remove_const</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">remove_volatile</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">remove_cv</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">add_const</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">add_volatile</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">add_cv</span><span class="special">;</span>

<span class="comment">// [4.7.2] reference modifications:</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">remove_reference</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">add_reference</span><span class="special">;</span>

<span class="comment">// [4.7.3] array modifications:</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">remove_extent</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">remove_all_extents</span><span class="special">;</span>

<span class="comment">// [4.7.4] pointer modifications:</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">remove_pointer</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">add_pointer</span><span class="special">;</span>

<span class="comment">// [4.8] other transformations:</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Len</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Align</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">aligned_storage</span><span class="special">;</span>

<span class="special">}</span> <span class="comment">// namespace tr1</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre>
<p>
        <span class="bold"><strong>Configuration:</strong></span> <a href="../../../libs/config/index.html" target="_top">Boost.Config</a>
        should (automatically) define the macro BOOST_HAS_TR1_TYPE_TRAITS if your
        standard library implements this part of TR1.
      </p>
<p>
        <span class="bold"><strong>Standard Conformity:</strong></span> No known problems.
      </p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_tr1.subject_list.random"></a><a class="link" href="subject_list.html#boost_tr1.subject_list.random" title="Random Number Generators and Distributions.">Random Number Generators
      and Distributions.</a>
</h3></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">tr1</span><span class="special">/</span><span class="identifier">random</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
        or
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">random</span><span class="special">&gt;</span>
</pre>
<p>
        The random number library is divided into three parts: <a href="../../../libs/random/random-generators.html" target="_top">generators</a>,
        which are nullary functors producing uniform random number distributions.
        <a href="../../../libs/random/random-distributions.html" target="_top">Distributions</a>,
        which are unary functors that adapt a generator to some specific kind of
        distribution. And the class template <a href="../../../libs/random/random-variate.html" target="_top">variate_generator</a>
        which combines a generator with a distribution, to create a new generator.
        For more information see the <a href="../../../libs/random/index.html" target="_top">Boost.Random
        documentation</a>.
      </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">tr1</span> <span class="special">{</span>

<span class="comment">// [5.1.3] Class template variate_generator</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">UniformRandomNumberGenerator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Distribution</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">variate_generator</span><span class="special">;</span>

<span class="comment">// [5.1.4.1] Class template linear_congruential</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">IntType</span><span class="special">,</span> <span class="identifier">IntType</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">IntType</span> <span class="identifier">c</span><span class="special">,</span> <span class="identifier">IntType</span> <span class="identifier">m</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">linear_congruential</span><span class="special">;</span>

<span class="comment">// [5.1.4.2] Class template mersenne_twister</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">UIntType</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">w</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">m</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">r</span><span class="special">,</span>
<span class="identifier">UIntType</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">u</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">s</span><span class="special">,</span> <span class="identifier">UIntType</span> <span class="identifier">b</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">t</span><span class="special">,</span> <span class="identifier">UIntType</span> <span class="identifier">c</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">l</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">mersenne_twister</span><span class="special">;</span>

<span class="comment">// [5.1.4.3] Class template substract_with_carry</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">IntType</span><span class="special">,</span> <span class="identifier">IntType</span> <span class="identifier">m</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">s</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">r</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">subtract_with_carry</span><span class="special">;</span>

<span class="comment">// [5.1.4.4] Class template substract_with_carry_01</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RealType</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">w</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">s</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">r</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">subtract_with_carry_01</span><span class="special">;</span>

<span class="comment">// [5.1.4.5] Class template discard_block</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">UniformRandomNumberGenerator</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">p</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">r</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">discard_block</span><span class="special">;</span>

<span class="comment">// [5.1.4.6] Class template xor_combine</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">UniformRandomNumberGenerator1</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">s1</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">UniformRandomNumberGenerator2</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">s2</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">xor_combine</span><span class="special">;</span>

<span class="comment">// [5.1.5] Predefined generators</span>
<span class="keyword">typedef</span> <span class="identifier">linear_congruential</span><span class="special">&lt;</span>
            <span class="identifier">implementation</span><span class="special">-</span><span class="identifier">defined</span> <span class="special">,</span>
            <span class="number">16807</span><span class="special">,</span>
            <span class="number">0</span><span class="special">,</span>
            <span class="number">2147483647</span><span class="special">&gt;</span> <span class="identifier">minstd_rand0</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">linear_congruential</span><span class="special">&lt;</span>
            <span class="identifier">implementation</span><span class="special">-</span><span class="identifier">defined</span> <span class="special">,</span>
            <span class="number">48271</span><span class="special">,</span>
            <span class="number">0</span><span class="special">,</span>
            <span class="number">2147483647</span><span class="special">&gt;</span> <span class="identifier">minstd_rand</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">mersenne_twister</span><span class="special">&lt;</span>
            <span class="identifier">implementation</span><span class="special">-</span><span class="identifier">defined</span> <span class="special">,</span>
            <span class="number">32</span><span class="special">,</span> <span class="number">624</span><span class="special">,</span> <span class="number">397</span><span class="special">,</span> <span class="number">31</span><span class="special">,</span>
            <span class="number">0x9908b0df</span><span class="special">,</span> <span class="number">11</span><span class="special">,</span> <span class="number">7</span><span class="special">,</span>
            <span class="number">0x9d2c5680</span><span class="special">,</span> <span class="number">15</span><span class="special">,</span>
            <span class="number">0xefc60000</span><span class="special">,</span> <span class="number">18</span><span class="special">&gt;</span> <span class="identifier">mt19937</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">subtract_with_carry_01</span><span class="special">&lt;</span>
            <span class="keyword">float</span><span class="special">,</span>
            <span class="number">24</span><span class="special">,</span>
            <span class="number">10</span><span class="special">,</span>
            <span class="number">24</span><span class="special">&gt;</span> <span class="identifier">ranlux_base_01</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">subtract_with_carry_01</span><span class="special">&lt;</span>
            <span class="keyword">double</span><span class="special">,</span>
            <span class="number">48</span><span class="special">,</span>
            <span class="number">10</span><span class="special">,</span>
            <span class="number">24</span><span class="special">&gt;</span> <span class="identifier">ranlux64_base_01</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">discard_block</span><span class="special">&lt;</span>
            <span class="identifier">subtract_with_carry</span><span class="special">&lt;</span>
                  <span class="identifier">implementation</span><span class="special">-</span><span class="identifier">defined</span> <span class="special">,</span>
                  <span class="special">(</span><span class="number">1</span><span class="special">&lt;&lt;</span><span class="number">24</span><span class="special">),</span>
                  <span class="number">10</span><span class="special">,</span>
                  <span class="number">24</span><span class="special">&gt;,</span>
            <span class="number">223</span><span class="special">,</span>
            <span class="number">24</span><span class="special">&gt;</span> <span class="identifier">ranlux3</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">discard_block</span><span class="special">&lt;</span>
            <span class="identifier">subtract_with_carry</span><span class="special">&lt;</span>
                  <span class="identifier">implementation</span><span class="special">-</span><span class="identifier">defined</span><span class="special">,</span>
                  <span class="special">(</span><span class="number">1</span><span class="special">&lt;&lt;</span><span class="number">24</span><span class="special">),</span>
                  <span class="number">10</span><span class="special">,</span>
                  <span class="number">24</span><span class="special">&gt;,</span>
            <span class="number">389</span><span class="special">,</span>
            <span class="number">24</span><span class="special">&gt;</span> <span class="identifier">ranlux4</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">discard_block</span><span class="special">&lt;</span>
            <span class="identifier">subtract_with_carry_01</span><span class="special">&lt;</span>
                  <span class="keyword">float</span><span class="special">,</span>
                  <span class="number">24</span><span class="special">,</span>
                  <span class="number">10</span><span class="special">,</span>
                  <span class="number">24</span><span class="special">&gt;,</span>
            <span class="number">223</span><span class="special">,</span>
            <span class="number">24</span><span class="special">&gt;</span> <span class="identifier">ranlux3_01</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">discard_block</span><span class="special">&lt;</span>
            <span class="identifier">subtract_with_carry_01</span><span class="special">&lt;</span>
                  <span class="keyword">float</span><span class="special">,</span>
                  <span class="number">24</span><span class="special">,</span>
                  <span class="number">10</span><span class="special">,</span>
                  <span class="number">24</span><span class="special">&gt;,</span>
            <span class="number">389</span><span class="special">,</span>
            <span class="number">24</span><span class="special">&gt;</span> <span class="identifier">ranlux4_01</span><span class="special">;</span>

<span class="comment">// [5.1.6] Class random_device</span>
<span class="keyword">class</span> <span class="identifier">random_device</span><span class="special">;</span>

<span class="comment">// [5.1.7.1] Class template uniform_int</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">IntType</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">uniform_int</span><span class="special">;</span>

<span class="comment">// [5.1.7.2] Class bernoulli_distribution</span>
<span class="keyword">class</span> <span class="identifier">bernoulli_distribution</span><span class="special">;</span>

<span class="comment">// [5.1.7.3] Class template geometric_distribution</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">IntType</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">RealType</span> <span class="special">=</span> <span class="keyword">double</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">geometric_distribution</span><span class="special">;</span>

<span class="comment">// [5.1.7.4] Class template poisson_distribution</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">IntType</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">RealType</span> <span class="special">=</span> <span class="keyword">double</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">poisson_distribution</span><span class="special">;</span>

<span class="comment">// [5.1.7.5] Class template binomial_distribution</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">IntType</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">RealType</span> <span class="special">=</span> <span class="keyword">double</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">binomial_distribution</span><span class="special">;</span>

<span class="comment">// [5.1.7.6] Class template uniform_real</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RealType</span> <span class="special">=</span> <span class="keyword">double</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">uniform_real</span><span class="special">;</span>

<span class="comment">// [5.1.7.7] Class template exponential_distribution</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RealType</span> <span class="special">=</span> <span class="keyword">double</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">exponential_distribution</span><span class="special">;</span>

<span class="comment">// [5.1.7.8] Class template normal_distribution</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RealType</span> <span class="special">=</span> <span class="keyword">double</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">normal_distribution</span><span class="special">;</span>

<span class="comment">// [5.1.7.9] Class template gamma_distribution</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RealType</span> <span class="special">=</span> <span class="keyword">double</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">gamma_distribution</span><span class="special">;</span>

<span class="special">}</span> <span class="comment">// namespace tr1</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre>
<p>
        <span class="bold"><strong>Configuration:</strong></span> <a href="../../../libs/config/index.html" target="_top">Boost.Config</a>
        should (automatically) define the macro BOOST_HAS_TR1_RANDOM if your standard
        library implements this part of TR1.
      </p>
<p>
        <span class="bold"><strong>Standard Conformity:</strong></span> The Boost implementation
        has the following limitations:
      </p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
            The linear_congruential generator is fully supported for signed integer
            types only (unsigned types probably only work when the modulus is zero).
          </li>
<li class="listitem">
            The subtract_with_carry template does not support a modulus of zero.
          </li>
<li class="listitem">
            Not all of the standard generator types have Boost documentation yet,
            they are none the less supported however.
          </li>
<li class="listitem">
            Class template variate_generator does not have a template unary function
            call operator(), only the non-template nullary version.
          </li>
</ul></div>
<p>
        Note also that most of the Random number generators have been re-implemented
        as thin wrappers around the Boost versions in order to provide a standard
        conforming interface (the Boost versions all take an additional, redundant,
        template parameter, and are initialized by iterators rather than functors).
      </p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_tr1.subject_list.tuple"></a><a class="link" href="subject_list.html#boost_tr1.subject_list.tuple" title="Tuples.">Tuples.</a>
</h3></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">tr1</span><span class="special">/</span><span class="identifier">tuple</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
        or
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">tuple</span><span class="special">&gt;</span>
</pre>
<p>
        A tuple is a fixed size collection of elements. Pairs, triples, quadruples
        etc. are tuples. In a programming language, a tuple is a data object containing
        other objects as elements. These element objects may be of different types.
        Tuples are convenient in many circumstances. For instance, tuples make it
        easy to define functions that return more than one value. Some programming
        languages, such as ML, Python and Haskell, have built-in tuple constructs.
        Unfortunately C++ does not. To compensate for this "deficiency",
        the TR1 Tuple Library implements a tuple construct using templates. For more
        information see the <a href="../../../libs/tuple/index.html" target="_top">Boost Tuple
        Library Documentation</a>.
      </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">tr1</span> <span class="special">{</span>

<span class="comment">// [6.1.3] Class template tuple</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span> <span class="special">=</span> <span class="identifier">unspecified</span> <span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">T2</span> <span class="special">=</span> <span class="identifier">unspecified</span> <span class="special">,</span>
<span class="special">...,</span>
<span class="keyword">class</span> <span class="identifier">TM</span> <span class="special">=</span> <span class="identifier">unspecified</span> <span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">tuple</span><span class="special">;</span>

<span class="comment">// [6.1.3.2] Tuple creation functions</span>
<span class="keyword">const</span> <span class="identifier">unspecified</span> <span class="identifier">ignore</span><span class="special">;</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="special">...,</span> <span class="keyword">class</span> <span class="identifier">TN</span><span class="special">&gt;</span>
<span class="identifier">tuple</span><span class="special">&lt;</span><span class="identifier">V1</span><span class="special">,</span> <span class="identifier">V2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">VN</span><span class="special">&gt;</span> <span class="identifier">make_tuple</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T1</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">T2</span><span class="special">&amp;</span> <span class="special">,</span> <span class="special">...,</span> <span class="keyword">const</span> <span class="identifier">TN</span><span class="special">&amp;);</span>

<span class="comment">// [6.1] Tuple types Containers</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="special">...,</span> <span class="keyword">class</span> <span class="identifier">TN</span><span class="special">&gt;</span>
<span class="identifier">tuple</span><span class="special">&lt;</span><span class="identifier">T1</span><span class="special">&amp;,</span> <span class="identifier">T2</span><span class="special">&amp;,</span> <span class="special">...,</span> <span class="identifier">TN</span><span class="special">&amp;&gt;</span> <span class="identifier">tie</span><span class="special">(</span><span class="identifier">T1</span><span class="special">&amp;,</span> <span class="identifier">T2</span><span class="special">&amp;</span> <span class="special">,</span> <span class="special">...,</span> <span class="identifier">TN</span><span class="special">&amp;);</span>

<span class="comment">// [6.1.3.3] Tuple helper classes</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">tuple_size</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">int</span> <span class="identifier">I</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">tuple_element</span><span class="special">;</span>

<span class="comment">// [6.1.3.4] Element access</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">int</span> <span class="identifier">I</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="special">...,</span> <span class="keyword">class</span> <span class="identifier">TN</span><span class="special">&gt;</span>
<span class="identifier">RI</span> <span class="identifier">get</span><span class="special">(</span><span class="identifier">tuple</span><span class="special">&lt;</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">TN</span><span class="special">&gt;&amp;);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">int</span> <span class="identifier">I</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="special">...,</span> <span class="keyword">class</span> <span class="identifier">TN</span><span class="special">&gt;</span>
<span class="identifier">PI</span> <span class="identifier">get</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">tuple</span><span class="special">&lt;</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">TN</span><span class="special">&gt;&amp;);</span>

<span class="comment">// [6.1.3.5] relational operators</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="special">...,</span> <span class="keyword">class</span> <span class="identifier">TM</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U2</span><span class="special">,</span> <span class="special">...,</span> <span class="keyword">class</span> <span class="identifier">UM</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">tuple</span><span class="special">&lt;</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">TM</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">tuple</span><span class="special">&lt;</span><span class="identifier">U1</span><span class="special">,</span> <span class="identifier">U2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">UM</span><span class="special">&gt;&amp;);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="special">...,</span> <span class="keyword">class</span> <span class="identifier">TM</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U2</span><span class="special">,</span> <span class="special">...,</span> <span class="keyword">class</span> <span class="identifier">UM</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;(</span><span class="keyword">const</span> <span class="identifier">tuple</span><span class="special">&lt;</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">TM</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">tuple</span><span class="special">&lt;</span><span class="identifier">U1</span><span class="special">,</span> <span class="identifier">U2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">UM</span><span class="special">&gt;&amp;);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="special">...,</span> <span class="keyword">class</span> <span class="identifier">TM</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U2</span><span class="special">,</span> <span class="special">...,</span> <span class="keyword">class</span> <span class="identifier">UM</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">tuple</span><span class="special">&lt;</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">TM</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">tuple</span><span class="special">&lt;</span><span class="identifier">U1</span><span class="special">,</span> <span class="identifier">U2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">UM</span><span class="special">&gt;&amp;);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="special">...,</span> <span class="keyword">class</span> <span class="identifier">TM</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U2</span><span class="special">,</span> <span class="special">...,</span> <span class="keyword">class</span> <span class="identifier">UM</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;(</span><span class="keyword">const</span> <span class="identifier">tuple</span><span class="special">&lt;</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">TM</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">tuple</span><span class="special">&lt;</span><span class="identifier">U1</span><span class="special">,</span> <span class="identifier">U2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">UM</span><span class="special">&gt;&amp;);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="special">...,</span> <span class="keyword">class</span> <span class="identifier">TM</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U2</span><span class="special">,</span> <span class="special">...,</span> <span class="keyword">class</span> <span class="identifier">UM</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">tuple</span><span class="special">&lt;</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">TM</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">tuple</span><span class="special">&lt;</span><span class="identifier">U1</span><span class="special">,</span> <span class="identifier">U2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">UM</span><span class="special">&gt;&amp;);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="special">...,</span> <span class="keyword">class</span> <span class="identifier">TM</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U2</span><span class="special">,</span> <span class="special">...,</span> <span class="keyword">class</span> <span class="identifier">UM</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">tuple</span><span class="special">&lt;</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">TM</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">tuple</span><span class="special">&lt;</span><span class="identifier">U1</span><span class="special">,</span> <span class="identifier">U2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">UM</span><span class="special">&gt;&amp;);</span>

<span class="special">}</span> <span class="comment">// namespace tr1</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre>
<p>
        <span class="bold"><strong>Configuration:</strong></span> <a href="../../../libs/config/index.html" target="_top">Boost.Config</a>
        should (automatically) define the macro BOOST_HAS_TR1_TUPLE if your standard
        library implements this part of TR1.
      </p>
<p>
        <span class="bold"><strong>Standard Conformity:</strong></span> No known issues for
        conforming compilers.
      </p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_tr1.subject_list.utility"></a><a class="link" href="subject_list.html#boost_tr1.subject_list.utility" title="Tuple Interface to std::pair.">Tuple Interface to std::pair.</a>
</h3></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">tr1</span><span class="special">/</span><span class="identifier">utility</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
        or
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">utility</span><span class="special">&gt;</span>
</pre>
<p>
        The existing class template std::pair, can also be accessed using the <a class="link" href="subject_list.html#boost_tr1.subject_list.tuple" title="Tuples.">tuple interface</a>.
      </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">tr1</span> <span class="special">{</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">tuple_size</span><span class="special">;</span> <span class="comment">// forward declaration</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">int</span> <span class="identifier">I</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">tuple_element</span><span class="special">;</span> <span class="comment">// forward declaration</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">tuple_size</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">&gt;</span> <span class="special">&gt;;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">tuple_element</span><span class="special">&lt;</span><span class="number">0</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">T2</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">&gt;</span> <span class="special">&gt;;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">tuple_element</span><span class="special">&lt;</span><span class="number">1</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">T2</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">&gt;</span> <span class="special">&gt;;</span>
<span class="comment">// see below for definition of "P".</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="identifier">I</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">&gt;</span> <span class="identifier">P</span><span class="special">&amp;</span> <span class="identifier">get</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">&gt;&amp;);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="identifier">I</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">&gt;</span> <span class="keyword">const</span> <span class="identifier">P</span><span class="special">&amp;</span> <span class="identifier">get</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">&gt;&amp;);</span>

<span class="special">}</span> <span class="comment">// namespace tr1</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre>
<p>
        <span class="bold"><strong>Configuration:</strong></span> <a href="../../../libs/config/index.html" target="_top">Boost.Config</a>
        should (automatically) define the macro BOOST_HAS_TR1_UTILITY if your standard
        library implements this part of TR1.
      </p>
<p>
        <span class="bold"><strong>Standard Conformity:</strong></span> No known problems.
      </p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_tr1.subject_list.array"></a><a class="link" href="subject_list.html#boost_tr1.subject_list.array" title="Fixed Size Array.">Fixed Size Array.</a>
</h3></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">tr1</span><span class="special">/</span><span class="identifier">array</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
        or
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">array</span><span class="special">&gt;</span>
</pre>
<p>
        Class template array is a fixed size array that is safer than and no less
        efficient than a C style array. Class array fulfils almost all of the requirements
        of a reversible-container (see Section 23.1, [lib.container.requirements]
        of the C++ Standard). For more information refer to the <a href="../../../libs/array/index.html" target="_top">Boost.Array
        documentation</a>.
      </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">tr1</span> <span class="special">{</span>

<span class="comment">// [6.2.2] Class template array</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">N</span> <span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">array</span><span class="special">;</span>

<span class="comment">// Array comparisons</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">N</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">array</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">N</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">array</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">N</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">N</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">array</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">N</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">array</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">N</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">N</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">array</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">N</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">array</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">N</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">N</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">array</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">N</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">array</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">N</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">N</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;=</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">array</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">N</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">array</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">N</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">N</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;=</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">array</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">N</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">array</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">N</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>

<span class="comment">// [6.2.2.2] Specialized algorithms</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">N</span> <span class="special">&gt;</span> <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">array</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">N</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">array</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">N</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>

<span class="comment">// [6.2.2.5] Tuple interface to class template array</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">tuple_size</span><span class="special">;</span> <span class="comment">// forward declaration</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">int</span> <span class="identifier">I</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">tuple_element</span><span class="special">;</span> <span class="comment">// forward declaration</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">N</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">tuple_size</span><span class="special">&lt;</span><span class="identifier">array</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">N</span><span class="special">&gt;</span> <span class="special">&gt;;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">int</span> <span class="identifier">I</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">N</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">tuple_element</span><span class="special">&lt;</span><span class="identifier">I</span><span class="special">,</span> <span class="identifier">array</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">N</span><span class="special">&gt;</span> <span class="special">&gt;;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">int</span> <span class="identifier">I</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">N</span><span class="special">&gt;</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">get</span><span class="special">(</span> <span class="identifier">array</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">N</span><span class="special">&gt;&amp;);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">int</span> <span class="identifier">I</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">N</span><span class="special">&gt;</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">get</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">array</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">N</span><span class="special">&gt;&amp;);</span>

<span class="special">}</span> <span class="comment">// namespace tr1</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre>
<p>
        <span class="bold"><strong>Configuration:</strong></span> <a href="../../../libs/config/index.html" target="_top">Boost.Config</a>
        should (automatically) define the macro BOOST_HAS_TR1_ARRAY if your standard
        library implements this part of TR1.
      </p>
<p>
        <span class="bold"><strong>Standard Conformity:</strong></span> No known issues as
        of Boost-1.34 onwards.
      </p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_tr1.subject_list.hash"></a><a class="link" href="subject_list.html#boost_tr1.subject_list.hash" title="Hash Function Objects.">Hash Function Objects.</a>
</h3></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">tr1</span><span class="special">/</span><span class="identifier">functional</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
        or
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">functional</span><span class="special">&gt;</span>
</pre>
<p>
        Class template std::hash is a unary-functor that converts some type T into
        a hash-value, specializations of std::hash are provided for integer, character,
        floating point, and pointer types, plus the two string types std::string
        and std::wstring. See the <a href="../../../libs/functional/hash/index.html" target="_top">Boost.Hash</a>
        documentation for more information.
      </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">tr1</span> <span class="special">{</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">hash</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">unary_function</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">size_t</span><span class="special">&gt;</span>
<span class="special">{</span>
   <span class="identifier">size_t</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">T</span> <span class="identifier">val</span><span class="special">)</span><span class="keyword">const</span><span class="special">;</span>
<span class="special">};</span>

<span class="comment">// Hash function specializations</span>
<span class="keyword">template</span> <span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">&gt;;</span>
<span class="keyword">template</span> <span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;;</span>
<span class="keyword">template</span> <span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="keyword">signed</span> <span class="keyword">char</span><span class="special">&gt;;</span>
<span class="keyword">template</span> <span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="keyword">char</span><span class="special">&gt;;</span>
<span class="keyword">template</span> <span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="keyword">wchar_t</span><span class="special">&gt;;</span>
<span class="keyword">template</span> <span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="keyword">short</span><span class="special">&gt;;</span>
<span class="keyword">template</span> <span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;;</span>
<span class="keyword">template</span> <span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="keyword">long</span><span class="special">&gt;;</span>
<span class="keyword">template</span> <span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="keyword">short</span><span class="special">&gt;;</span>
<span class="keyword">template</span> <span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="keyword">int</span><span class="special">&gt;;</span>
<span class="keyword">template</span> <span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="keyword">long</span><span class="special">&gt;;</span>
<span class="keyword">template</span> <span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">&gt;;</span>
<span class="keyword">template</span> <span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;;</span>
<span class="keyword">template</span> <span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="keyword">double</span><span class="special">&gt;;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">*&gt;;</span>
<span class="keyword">template</span> <span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;;</span>
<span class="keyword">template</span> <span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">wstring</span><span class="special">&gt;;</span>

<span class="special">}</span> <span class="comment">// namespace tr1</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre>
<p>
        <span class="bold"><strong>Configuration:</strong></span> <a href="../../../libs/config/index.html" target="_top">Boost.Config</a>
        should (automatically) define the macro BOOST_HAS_TR1_HASH if your standard
        library implements this part of TR1.
      </p>
<p>
        <span class="bold"><strong>Standard Conformity:</strong></span> Boost.Hash adds specialisations
        of std::hash for a wider range of types than those required by TR1: Boost.Hash
        acts as a testbed for issue 6.18 in the <a href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf" target="_top">Library
        Extension Technical Report Issues List</a>.
      </p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
          There are portability issues with this template - in particular the <code class="computeroutput"><span class="identifier">hash</span></code> template might not actually be defined
          inside namespace std::tr1, making user-defined specializations of the template
          non-portable. For example Visual C++ 2010 defines <code class="computeroutput"><span class="identifier">hash</span></code>
          in namespace <code class="computeroutput"><span class="identifier">std</span></code> and then
          imports this into <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">tr1</span></code> with a using declaration.
        </p></td></tr>
</table></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_tr1.subject_list.regex"></a><a class="link" href="subject_list.html#boost_tr1.subject_list.regex" title="Regular Expressions.">Regular Expressions.</a>
</h3></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">tr1</span><span class="special">/</span><span class="identifier">regex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
        or
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">regex</span><span class="special">&gt;</span>
</pre>
<p>
        This library provides comprehensive support for regular expressions, including
        either iterator or string based matching, searching, search-and-replace,
        iteration, and tokenization. Both POSIX and ECMAScript (JavaScript) regular
        expressions are supported. For more information see the <a href="../../../libs/regex/index.html" target="_top">Boost.Regex
        documentation</a>.
      </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">tr1</span> <span class="special">{</span>

<span class="comment">// [7.5] Regex constants</span>
<span class="keyword">namespace</span> <span class="identifier">regex_constants</span> <span class="special">{</span>

<span class="keyword">typedef</span> <span class="identifier">bitmask_type</span> <span class="identifier">syntax_option_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">bitmask_type</span> <span class="identifier">match_flag_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">implementation</span><span class="special">-</span><span class="identifier">defined</span> <span class="identifier">error_type</span><span class="special">;</span>

<span class="special">}</span> <span class="comment">// namespace regex_constants</span>

<span class="comment">// [7.6] Class regex_error</span>
<span class="keyword">class</span> <span class="identifier">regex_error</span><span class="special">;</span>

<span class="comment">// [7.7] Class template regex_traits</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">regex_traits</span><span class="special">;</span>

<span class="comment">// [7.8] Class template basic_regex</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">traits</span> <span class="special">=</span> <span class="identifier">regex_traits</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">&gt;</span> <span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">basic_regex</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;</span> <span class="identifier">regex</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="keyword">wchar_t</span><span class="special">&gt;</span> <span class="identifier">wregex</span><span class="special">;</span>

<span class="comment">// [7.8.6] basic_regex swap</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">traits</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">traits</span><span class="special">&gt;&amp;</span> <span class="identifier">e1</span><span class="special">,</span>
         <span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">traits</span><span class="special">&gt;&amp;</span> <span class="identifier">e2</span><span class="special">);</span>

<span class="comment">// [7.9] Class template sub_match</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">BidirectionalIterator</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">sub_match</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">sub_match</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*&gt;</span> <span class="identifier">csub_match</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">sub_match</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">wchar_t</span><span class="special">*&gt;</span> <span class="identifier">wcsub_match</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">sub_match</span><span class="special">&lt;</span><span class="identifier">string</span><span class="special">::</span><span class="identifier">const_iterator</span><span class="special">&gt;</span> <span class="identifier">ssub_match</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">sub_match</span><span class="special">&lt;</span><span class="identifier">wstring</span><span class="special">::</span><span class="identifier">const_iterator</span><span class="special">&gt;</span> <span class="identifier">wssub_match</span><span class="special">;</span>

<span class="comment">// [7.9.2] sub_match non-member operators</span>

<span class="comment">/* Comparison operators omitted for clarity.... */</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ST</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">BiIter</span><span class="special">&gt;</span>
<span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">ST</span><span class="special">&gt;&amp;</span>
   <span class="keyword">operator</span><span class="special">&lt;&lt;(</span><span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">ST</span><span class="special">&gt;&amp;</span> <span class="identifier">os</span><span class="special">,</span>
            <span class="keyword">const</span> <span class="identifier">sub_match</span><span class="special">&lt;</span><span class="identifier">BiIter</span><span class="special">&gt;&amp;</span> <span class="identifier">m</span><span class="special">);</span>

<span class="comment">// [7.10] Class template match_results</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">BidirectionalIterator</span><span class="special">,</span>
         <span class="keyword">class</span> <span class="identifier">Allocator</span> <span class="special">=</span> <span class="identifier">allocator</span><span class="special">&lt;</span><span class="identifier">sub_match</span><span class="special">&lt;</span><span class="identifier">BidirectionalIterator</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">match_results</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">match_results</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*&gt;</span> <span class="identifier">cmatch</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">match_results</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">wchar_t</span><span class="special">*&gt;</span> <span class="identifier">wcmatch</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">match_results</span><span class="special">&lt;</span><span class="identifier">string</span><span class="special">::</span><span class="identifier">const_iterator</span><span class="special">&gt;</span> <span class="identifier">smatch</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">match_results</span><span class="special">&lt;</span><span class="identifier">wstring</span><span class="special">::</span><span class="identifier">const_iterator</span><span class="special">&gt;</span> <span class="identifier">wsmatch</span><span class="special">;</span>

<span class="comment">// match_results comparisons</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">BidirectionalIterator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">match_results</span><span class="special">&lt;</span><span class="identifier">BidirectionalIterator</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">m1</span><span class="special">,</span>
               <span class="keyword">const</span> <span class="identifier">match_results</span><span class="special">&lt;</span><span class="identifier">BidirectionalIterator</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">m2</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">BidirectionalIterator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">match_results</span><span class="special">&lt;</span><span class="identifier">BidirectionalIterator</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">m1</span><span class="special">,</span>
               <span class="keyword">const</span> <span class="identifier">match_results</span><span class="special">&lt;</span><span class="identifier">BidirectionalIterator</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">m2</span><span class="special">);</span>

<span class="comment">// [7.10.6] match_results swap</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">BidirectionalIterator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">match_results</span><span class="special">&lt;</span><span class="identifier">BidirectionalIterator</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">m1</span><span class="special">,</span>
         <span class="identifier">match_results</span><span class="special">&lt;</span><span class="identifier">BidirectionalIterator</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">m2</span><span class="special">);</span>

<span class="comment">// [7.11.2] Function template regex_match</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">BidirectionalIterator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">charT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">traits</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">regex_match</span><span class="special">(</span><span class="identifier">BidirectionalIterator</span> <span class="identifier">first</span><span class="special">,</span>
               <span class="identifier">BidirectionalIterator</span> <span class="identifier">last</span><span class="special">,</span>
               <span class="identifier">match_results</span><span class="special">&lt;</span><span class="identifier">BidirectionalIterator</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">m</span><span class="special">,</span>
               <span class="keyword">const</span> <span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">traits</span><span class="special">&gt;&amp;</span> <span class="identifier">e</span><span class="special">,</span>
               <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_flag_type</span> <span class="identifier">flags</span> <span class="special">=</span> <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_default</span><span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">BidirectionalIterator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">charT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">traits</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">regex_match</span><span class="special">(</span><span class="identifier">BidirectionalIterator</span> <span class="identifier">first</span><span class="special">,</span>
               <span class="identifier">BidirectionalIterator</span> <span class="identifier">last</span><span class="special">,</span>
               <span class="keyword">const</span> <span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">traits</span><span class="special">&gt;&amp;</span> <span class="identifier">e</span><span class="special">,</span>
               <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_flag_type</span> <span class="identifier">flags</span> <span class="special">=</span> <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_default</span><span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">traits</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">regex_match</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">charT</span><span class="special">*</span> <span class="identifier">str</span><span class="special">,</span>
               <span class="identifier">match_results</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">charT</span><span class="special">*,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">m</span><span class="special">,</span>
               <span class="keyword">const</span> <span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">traits</span><span class="special">&gt;&amp;</span> <span class="identifier">e</span><span class="special">,</span>
               <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_flag_type</span> <span class="identifier">flags</span> <span class="special">=</span> <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_default</span><span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ST</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">SA</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">charT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">traits</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">regex_match</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">basic_string</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">ST</span><span class="special">,</span> <span class="identifier">SA</span><span class="special">&gt;&amp;</span> <span class="identifier">s</span><span class="special">,</span>
               <span class="identifier">match_results</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">basic_string</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">ST</span><span class="special">,</span> <span class="identifier">SA</span><span class="special">&gt;::</span><span class="identifier">const_iterator</span><span class="special">,</span><span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">m</span><span class="special">,</span>
               <span class="keyword">const</span> <span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">traits</span><span class="special">&gt;&amp;</span> <span class="identifier">e</span><span class="special">,</span>
               <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_flag_type</span> <span class="identifier">flags</span> <span class="special">=</span> <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_default</span><span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">traits</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">regex_match</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">charT</span><span class="special">*</span> <span class="identifier">str</span><span class="special">,</span>
               <span class="keyword">const</span> <span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">traits</span><span class="special">&gt;&amp;</span> <span class="identifier">e</span><span class="special">,</span>
               <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_flag_type</span> <span class="identifier">flags</span> <span class="special">=</span> <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_default</span><span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ST</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">SA</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">charT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">traits</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">regex_match</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">basic_string</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">ST</span><span class="special">,</span> <span class="identifier">SA</span><span class="special">&gt;&amp;</span> <span class="identifier">s</span><span class="special">,</span>
               <span class="keyword">const</span> <span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">traits</span><span class="special">&gt;&amp;</span> <span class="identifier">e</span><span class="special">,</span>
               <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_flag_type</span> <span class="identifier">flags</span> <span class="special">=</span> <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_default</span><span class="special">);</span>

<span class="comment">// [7.11.3] Function template regex_search</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">BidirectionalIterator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">charT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">traits</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">regex_search</span><span class="special">(</span><span class="identifier">BidirectionalIterator</span> <span class="identifier">first</span><span class="special">,</span>
                  <span class="identifier">BidirectionalIterator</span> <span class="identifier">last</span><span class="special">,</span>
                  <span class="identifier">match_results</span><span class="special">&lt;</span><span class="identifier">BidirectionalIterator</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">m</span><span class="special">,</span>
                  <span class="keyword">const</span> <span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">traits</span><span class="special">&gt;&amp;</span> <span class="identifier">e</span><span class="special">,</span>
                  <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_flag_type</span> <span class="identifier">flags</span> <span class="special">=</span> <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_default</span><span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">BidirectionalIterator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">charT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">traits</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">regex_search</span><span class="special">(</span><span class="identifier">BidirectionalIterator</span> <span class="identifier">first</span><span class="special">,</span>
                  <span class="identifier">BidirectionalIterator</span> <span class="identifier">last</span><span class="special">,</span>
                  <span class="keyword">const</span> <span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">traits</span><span class="special">&gt;&amp;</span> <span class="identifier">e</span><span class="special">,</span>
                  <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_flag_type</span> <span class="identifier">flags</span> <span class="special">=</span> <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_default</span><span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">traits</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">regex_search</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">charT</span><span class="special">*</span> <span class="identifier">str</span><span class="special">,</span>
                  <span class="identifier">match_results</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">charT</span><span class="special">*,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">m</span><span class="special">,</span>
                  <span class="keyword">const</span> <span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">traits</span><span class="special">&gt;&amp;</span> <span class="identifier">e</span><span class="special">,</span>
                  <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_flag_type</span> <span class="identifier">flags</span> <span class="special">=</span> <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_default</span><span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">traits</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">regex_search</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">charT</span><span class="special">*</span> <span class="identifier">str</span><span class="special">,</span>
                  <span class="keyword">const</span> <span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">traits</span><span class="special">&gt;&amp;</span> <span class="identifier">e</span><span class="special">,</span>
                  <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_flag_type</span> <span class="identifier">flags</span> <span class="special">=</span> <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_default</span><span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ST</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">SA</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">charT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">traits</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">regex_search</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">basic_string</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">ST</span><span class="special">,</span> <span class="identifier">SA</span><span class="special">&gt;&amp;</span> <span class="identifier">s</span><span class="special">,</span>
                  <span class="keyword">const</span> <span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">traits</span><span class="special">&gt;&amp;</span> <span class="identifier">e</span><span class="special">,</span>
                  <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_flag_type</span> <span class="identifier">flags</span> <span class="special">=</span> <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_default</span><span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ST</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">SA</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">charT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">traits</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">regex_search</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">basic_string</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">ST</span><span class="special">,</span> <span class="identifier">SA</span><span class="special">&gt;&amp;</span> <span class="identifier">s</span><span class="special">,</span>
                  <span class="identifier">match_results</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">basic_string</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">ST</span><span class="special">,</span> <span class="identifier">SA</span><span class="special">&gt;::</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">m</span><span class="special">,</span>
                  <span class="keyword">const</span> <span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">traits</span><span class="special">&gt;&amp;</span> <span class="identifier">e</span><span class="special">,</span>
                  <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_flag_type</span> <span class="identifier">flags</span> <span class="special">=</span> <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_default</span><span class="special">);</span>

<span class="comment">// [7.11.4] Function template regex_replace</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">OutputIterator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">BidirectionalIterator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">traits</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">charT</span><span class="special">&gt;</span>
<span class="identifier">OutputIterator</span> <span class="identifier">regex_replace</span><span class="special">(</span><span class="identifier">OutputIterator</span> <span class="identifier">out</span><span class="special">,</span>
                           <span class="identifier">BidirectionalIterator</span> <span class="identifier">first</span><span class="special">,</span>
                           <span class="identifier">BidirectionalIterator</span> <span class="identifier">last</span><span class="special">,</span>
                           <span class="keyword">const</span> <span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">traits</span><span class="special">&gt;&amp;</span> <span class="identifier">e</span><span class="special">,</span>
                           <span class="keyword">const</span> <span class="identifier">basic_string</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">&gt;&amp;</span> <span class="identifier">fmt</span><span class="special">,</span>
                           <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_flag_type</span> <span class="identifier">flags</span> <span class="special">=</span> <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_default</span><span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">traits</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">charT</span><span class="special">&gt;</span>
<span class="identifier">basic_string</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">&gt;</span> <span class="identifier">regex_replace</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">basic_string</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">&gt;&amp;</span> <span class="identifier">s</span><span class="special">,</span>
                                       <span class="keyword">const</span> <span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">traits</span><span class="special">&gt;&amp;</span> <span class="identifier">e</span><span class="special">,</span>
                                       <span class="keyword">const</span> <span class="identifier">basic_string</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">&gt;&amp;</span> <span class="identifier">fmt</span><span class="special">,</span>
                                       <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_flag_type</span> <span class="identifier">flags</span> <span class="special">=</span> <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_default</span><span class="special">);</span>

<span class="comment">// [7.12.1] Class template regex_iterator</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">BidirectionalIterator</span><span class="special">,</span>
         <span class="keyword">class</span> <span class="identifier">charT</span> <span class="special">=</span> <span class="keyword">typename</span> <span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">BidirectionalIterator</span><span class="special">&gt;::</span><span class="identifier">value_type</span><span class="special">,</span>
         <span class="keyword">class</span> <span class="identifier">traits</span> <span class="special">=</span> <span class="identifier">regex_traits</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">&gt;</span> <span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">regex_iterator</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">regex_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*&gt;</span> <span class="identifier">cregex_iterator</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">regex_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">wchar_t</span><span class="special">*&gt;</span> <span class="identifier">wcregex_iterator</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">regex_iterator</span><span class="special">&lt;</span><span class="identifier">string</span><span class="special">::</span><span class="identifier">const_iterator</span><span class="special">&gt;</span> <span class="identifier">sregex_iterator</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">regex_iterator</span><span class="special">&lt;</span><span class="identifier">wstring</span><span class="special">::</span><span class="identifier">const_iterator</span><span class="special">&gt;</span> <span class="identifier">wsregex_iterator</span><span class="special">;</span>

<span class="comment">// [7.12.2] Class template regex_token_iterator</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">BidirectionalIterator</span><span class="special">,</span>
         <span class="keyword">class</span> <span class="identifier">charT</span> <span class="special">=</span> <span class="keyword">typename</span> <span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">BidirectionalIterator</span><span class="special">&gt;::</span><span class="identifier">value_type</span><span class="special">,</span>
         <span class="keyword">class</span> <span class="identifier">traits</span> <span class="special">=</span> <span class="identifier">regex_traits</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">&gt;</span> <span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">regex_token_iterator</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">regex_token_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*&gt;</span> <span class="identifier">cregex_token_iterator</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">regex_token_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">wchar_t</span><span class="special">*&gt;</span> <span class="identifier">wcregex_token_iterator</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">regex_token_iterator</span><span class="special">&lt;</span><span class="identifier">string</span><span class="special">::</span><span class="identifier">const_iterator</span><span class="special">&gt;</span> <span class="identifier">sregex_token_iterator</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">regex_token_iterator</span><span class="special">&lt;</span><span class="identifier">wstring</span><span class="special">::</span><span class="identifier">const_iterator</span><span class="special">&gt;</span> <span class="identifier">wsregex_token_iterator</span><span class="special">;</span>

<span class="special">}</span> <span class="comment">// namespace tr1</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre>
<p>
        <span class="bold"><strong>Configuration:</strong></span> <a href="../../../libs/config/index.html" target="_top">Boost.Config</a>
        should (automatically) define the macro BOOST_HAS_TR1_REGEX if your standard
        library implements this part of TR1.
      </p>
<p>
        <span class="bold"><strong>Standard Conformity:</strong></span> No known problems.
      </p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_tr1.subject_list.complex"></a><a class="link" href="subject_list.html#boost_tr1.subject_list.complex" title="Complex Number Algorithm Overloads.">Complex Number Algorithm
      Overloads.</a>
</h3></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">tr1</span><span class="special">/</span><span class="identifier">complex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
        or
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">complex</span><span class="special">&gt;</span>
</pre>
<p>
        The following function templates have additional overloads: <code class="computeroutput"><span class="identifier">arg</span></code>, <code class="computeroutput"><span class="identifier">norm</span></code>,
        <code class="computeroutput"><span class="identifier">conj</span></code>, <code class="computeroutput"><span class="identifier">polar</span></code>,
        <code class="computeroutput"><span class="identifier">imag</span></code>, and <code class="computeroutput"><span class="identifier">real</span></code>.
      </p>
<p>
        The additional overloads are sufficient to ensure:
      </p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
            If the argument has type <code class="computeroutput"><span class="keyword">long</span>
            <span class="keyword">double</span></code>, then the overload behaves
            as if the argument had been cast to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="keyword">double</span><span class="special">&gt;</span></code>.
          </li>
<li class="listitem">
            Otherwise, if the argument has type <code class="computeroutput"><span class="keyword">double</span></code>
            or is an integer type, then the overload behaves as if the argument had
            been cast to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span></code>.
          </li>
<li class="listitem">
            Otherwise, if the argument has type <code class="computeroutput"><span class="keyword">float</span></code>,
            then the overload behaves as if the argument had been cast to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">&gt;</span></code>.
          </li>
</ul></div>
<p>
        The function template <code class="computeroutput"><span class="identifier">pow</span></code>
        has additional overloads sufficient to ensure, for a call with at least one
        argument of type <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>:
      </p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
            If either argument has type <code class="computeroutput"><span class="identifier">complex</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="keyword">double</span><span class="special">&gt;</span></code>
            or type <code class="computeroutput"><span class="keyword">long</span> <span class="keyword">double</span></code>,
            then the overload behaves as if both arguments were cast to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="keyword">double</span><span class="special">&gt;</span></code>
          </li>
<li class="listitem">
            Otherwise, if either argument has type <code class="computeroutput"><span class="identifier">complex</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span></code>, <code class="computeroutput"><span class="keyword">double</span></code>,
            or an integer type, then the overload behaves as if both arguments were
            cast to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span></code>
          </li>
<li class="listitem">
            Otherwise, if either argument has type <code class="computeroutput"><span class="identifier">complex</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">&gt;</span></code> or <code class="computeroutput"><span class="keyword">float</span></code>,
            then the overload behaves as if both arguments were cast to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">&gt;</span></code>
          </li>
</ul></div>
<p>
        In the following synopsis, <code class="computeroutput"><span class="identifier">Real</span></code>
        is a floating point type, <code class="computeroutput"><span class="identifier">Arithmetic</span></code>
        is an integer or floating point type, and <code class="computeroutput"> <span class="identifier">PROMOTE</span><span class="special">(</span><span class="identifier">X1</span> <span class="special">...</span>
        <span class="identifier">XN</span><span class="special">)</span></code>
        is the largest floating point type in the list X1 to XN, after any non-floating
        point types in the list have been replaced by the type <code class="computeroutput"><span class="keyword">double</span></code>.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Arithmetic</span><span class="special">&gt;</span>
<span class="identifier">PROMOTE</span><span class="special">(</span><span class="identifier">Arithmetic</span><span class="special">)</span> <span class="identifier">arg</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Arithmetic</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Arithmetic</span><span class="special">&gt;</span>
<span class="identifier">PROMOTE</span><span class="special">(</span><span class="identifier">Arithmetic</span><span class="special">)</span> <span class="identifier">norm</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Arithmetic</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Arithmetic</span><span class="special">&gt;</span>
<span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">PROMOTE</span><span class="special">(</span><span class="identifier">Arithmetic</span><span class="special">)&gt;</span> <span class="identifier">conj</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Arithmetic</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Arithmetic1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Arithmetic2</span><span class="special">&gt;</span>
<span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">PROMOTE</span><span class="special">(</span><span class="identifier">Arithmetic1</span><span class="special">,</span><span class="identifier">Arithmetic2</span><span class="special">)&gt;</span> <span class="identifier">polar</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Arithmetic1</span><span class="special">&amp;</span> <span class="identifier">rho</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Arithmetic2</span><span class="special">&amp;</span> <span class="identifier">theta</span> <span class="special">=</span> <span class="number">0</span><span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Arithmetic</span><span class="special">&gt;</span>
<span class="identifier">PROMOTE</span><span class="special">(</span><span class="identifier">Arithmetic</span><span class="special">)</span> <span class="identifier">imag</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Arithmetic</span><span class="special">&amp;</span> <span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Arithmetic</span><span class="special">&gt;</span>
<span class="identifier">PROMOTE</span><span class="special">(</span><span class="identifier">Arithmetic</span><span class="special">)</span> <span class="identifier">real</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Arithmetic</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">);</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Real1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Real2</span><span class="special">&gt;</span>
<span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">PROMOTE</span><span class="special">(</span><span class="identifier">Real1</span><span class="special">,</span> <span class="identifier">Real2</span><span class="special">)&gt;</span>
   <span class="identifier">pow</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">Real1</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">Real2</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Real</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Arithmetic</span><span class="special">&gt;</span>
<span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">PROMOTE</span><span class="special">(</span><span class="identifier">Real</span><span class="special">,</span> <span class="identifier">Arithmetic</span><span class="special">)&gt;</span>
   <span class="identifier">pow</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">Real</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Arithmetic</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">);</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Arithmetic</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Real</span><span class="special">&gt;</span>
<span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">PROMOTE</span><span class="special">(</span><span class="identifier">Real</span><span class="special">,</span> <span class="identifier">Arithmetic</span><span class="special">)&gt;</span>
   <span class="identifier">pow</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">Arithmetic</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">Real</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>
</pre>
<p>
        <span class="bold"><strong>Configuration:</strong></span> <a href="../../../libs/config/index.html" target="_top">Boost.Config</a>
        should (automatically) define the macro BOOST_HAS_TR1_COMPLEX_OVERLOADS if
        your standard library implements the additional overloads for the existing
        complex arithmetic functions.
      </p>
<p>
        <span class="bold"><strong>Standard Conformity:</strong></span> No known problems.
      </p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_tr1.subject_list.complex_trig"></a><a class="link" href="subject_list.html#boost_tr1.subject_list.complex_trig" title="Complex Number Additional Algorithms.">Complex Number Additional
      Algorithms.</a>
</h3></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">tr1</span><span class="special">/</span><span class="identifier">complex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
        or
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">complex</span><span class="special">&gt;</span>
</pre>
<p>
        The algorithms <code class="computeroutput"><span class="identifier">acos</span></code>, <code class="computeroutput"><span class="identifier">asin</span></code>, <code class="computeroutput"><span class="identifier">atan</span></code>,
        <code class="computeroutput"><span class="identifier">acosh</span></code>, <code class="computeroutput"><span class="identifier">asinh</span></code>,
        <code class="computeroutput"><span class="identifier">atanh</span></code> and <code class="computeroutput"><span class="identifier">fabs</span></code>
        are overloaded for arguments of type <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>.
        These algorithms are entirely classical, and behave as specified in the C99
        standard section 7.3.5. See the <a href="../../../libs/math/doc/complex/html/complex_number_tr1_algorithms/inverse_complex.html" target="_top">Boost.Math
        documentation for more information</a>.
      </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">tr1</span> <span class="special">{</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">acos</span><span class="special">(</span><span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">asin</span><span class="special">(</span><span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">atan</span><span class="special">(</span><span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">acosh</span><span class="special">(</span><span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">asinh</span><span class="special">(</span><span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">atanh</span><span class="special">(</span><span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">fabs</span><span class="special">(</span><span class="identifier">complex</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">);</span>

<span class="special">}</span> <span class="comment">// namespace tr1</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre>
<p>
        <span class="bold"><strong>Configuration:</strong></span> <a href="../../../libs/config/index.html" target="_top">Boost.Config</a>
        should (automatically) define the macro BOOST_HAS_TR1_COMPLEX_INVERSE_TRIG
        if your standard library implements the additional inverse trig functions.
      </p>
<p>
        <span class="bold"><strong>Standard Conformity:</strong></span> No known problems.
      </p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_tr1.subject_list.unordered_set"></a><a class="link" href="subject_list.html#boost_tr1.subject_list.unordered_set" title="Unordered Associative Set (Hash Table).">Unordered Associative
      Set (Hash Table).</a>
</h3></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">tr1</span><span class="special">/</span><span class="identifier">unordered_set</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
        or
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">unordered_set</span><span class="special">&gt;</span>
</pre>
<p>
        For accessing data based on key lookup, the C++ standard library offers std::set,
        std::map, std::multiset and std::multimap. These are generally implemented
        using balanced binary trees so that lookup time has logarithmic complexity.
        That is generally okay, but in many cases a hash table can perform better,
        as accessing data has constant complexity, on average. The worst case complexity
        is linear, but that occurs rarely and with some care, can be avoided.
      </p>
<p>
        With this in mind, the C++ Standard Library Technical Report introduced the
        unordered associative containers, which are implemented using hash tables,
        and they have now been added to the Working Draft of the C++ Standard.
      </p>
<p>
        Refer to the <a href="../../../libs/unordered/index.html" target="_top">Unordered Library
        docs</a> for more information.
      </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">tr1</span> <span class="special">{</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Value</span><span class="special">,</span>
         <span class="keyword">class</span> <span class="identifier">Hash</span> <span class="special">=</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">&gt;,</span>
         <span class="keyword">class</span> <span class="identifier">Pred</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">equal_to</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">&gt;,</span>
         <span class="keyword">class</span> <span class="identifier">Alloc</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">&gt;</span> <span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">unordered_set</span><span class="special">;</span>

<span class="comment">// [6.3.4.5] Class template unordered_multiset</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Value</span><span class="special">,</span>
         <span class="keyword">class</span> <span class="identifier">Hash</span> <span class="special">=</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">&gt;,</span>
         <span class="keyword">class</span> <span class="identifier">Pred</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">equal_to</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">&gt;,</span>
         <span class="keyword">class</span> <span class="identifier">Alloc</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">&gt;</span> <span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">unordered_multiset</span><span class="special">;</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Value</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">unordered_set</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
         <span class="identifier">unordered_set</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Value</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">unordered_multiset</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
         <span class="identifier">unordered_multiset</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>

<span class="special">}</span> <span class="comment">// namespace tr1</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre>
<p>
        <span class="bold"><strong>Configuration:</strong></span> <a href="../../../libs/config/index.html" target="_top">Boost.Config</a>
        should (automatically) define the macro BOOST_HAS_TR1_UNORDERED_SET if your
        standard library implements this part of TR1.
      </p>
<p>
        <span class="bold"><strong>Standard Conformity:</strong></span> No known issues for
        conforming compilers.
      </p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_tr1.subject_list.unordered_map"></a><a class="link" href="subject_list.html#boost_tr1.subject_list.unordered_map" title="Unordered Associative Map (Hash Table).">Unordered Associative
      Map (Hash Table).</a>
</h3></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">tr1</span><span class="special">/</span><span class="identifier">unordered_map</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
        or
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">unordered_map</span><span class="special">&gt;</span>
</pre>
<p>
        For accessing data based on key lookup, the C++ standard library offers std::set,
        std::map, std::multiset and std::multimap. These are generally implemented
        using balanced binary trees so that lookup time has logarithmic complexity.
        That is generally okay, but in many cases a hash table can perform better,
        as accessing data has constant complexity, on average. The worst case complexity
        is linear, but that occurs rarely and with some care, can be avoided.
      </p>
<p>
        With this in mind, the C++ Standard Library Technical Report introduced the
        unordered associative containers, which are implemented using hash tables,
        and they have now been added to the Working Draft of the C++ Standard.
      </p>
<p>
        Refer to the <a href="../../../libs/unordered/index.html" target="_top">Unordered Library
        docs</a> for more information.
      </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">tr1</span> <span class="special">{</span>

<span class="comment">// [6.3.4.4] Class template unordered_map</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Key</span><span class="special">,</span>
         <span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span>
         <span class="keyword">class</span> <span class="identifier">Hash</span> <span class="special">=</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">&gt;,</span>
         <span class="keyword">class</span> <span class="identifier">Pred</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">equal_to</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">&gt;,</span>
         <span class="keyword">class</span> <span class="identifier">Alloc</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">unordered_map</span><span class="special">;</span>

<span class="comment">// [6.3.4.6] Class template unordered_multimap</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Key</span><span class="special">,</span>
         <span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span>
         <span class="keyword">class</span> <span class="identifier">Hash</span> <span class="special">=</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">&gt;,</span>
         <span class="keyword">class</span> <span class="identifier">Pred</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">equal_to</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">&gt;,</span>
         <span class="keyword">class</span> <span class="identifier">Alloc</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">unordered_multimap</span><span class="special">;</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Key</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">unordered_map</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
         <span class="identifier">unordered_map</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Key</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">unordered_multimap</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
         <span class="identifier">unordered_multimap</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>

<span class="special">}</span> <span class="comment">// namespace tr1</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre>
<p>
        <span class="bold"><strong>Configuration:</strong></span> <a href="../../../libs/config/index.html" target="_top">Boost.Config</a>
        should (automatically) define the macro BOOST_HAS_TR1_UNORDERED_MAP if your
        standard library implements this part of TR1.
      </p>
<p>
        <span class="bold"><strong>Standard Conformity:</strong></span> No known issues for
        conforming compilers.
      </p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_tr1.subject_list.special"></a><a class="link" href="subject_list.html#boost_tr1.subject_list.special" title="Mathematical Special Functions.">Mathematical Special
      Functions.</a>
</h3></div></div></div>
<p>
        The TR adds 23 special functions (plus float and long double overloads) to
        header &lt;cmath&gt;.
      </p>
<p>
        Refer to the <a href="../../../libs/math/doc/sf_and_dist/html/math_toolkit/main_overview/tr1.html" target="_top">Math
        Library docs</a> for more information.
      </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">tr1</span> <span class="special">{</span>

<span class="comment">// [5.2.1.1] associated Laguerre polynomials:</span>
<span class="keyword">double</span> <span class="identifier">assoc_laguerre</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">m</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">assoc_laguerref</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">m</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">assoc_laguerrel</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">m</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

<span class="comment">// [5.2.1.2] associated Legendre functions:</span>
<span class="keyword">double</span> <span class="identifier">assoc_legendre</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">l</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">m</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">assoc_legendref</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">l</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">m</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">assoc_legendrel</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">l</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">m</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

<span class="comment">// [5.2.1.3] beta function:</span>
<span class="keyword">double</span> <span class="identifier">beta</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">betaf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">y</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">betal</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">);</span>

<span class="comment">// [5.2.1.4] (complete) elliptic integral of the first kind:</span>
<span class="keyword">double</span> <span class="identifier">comp_ellint_1</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">k</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">comp_ellint_1f</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">k</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">comp_ellint_1l</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">k</span><span class="special">);</span>

<span class="comment">// [5.2.1.5] (complete) elliptic integral of the second kind:</span>
<span class="keyword">double</span> <span class="identifier">comp_ellint_2</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">k</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">comp_ellint_2f</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">k</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">comp_ellint_2l</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">k</span><span class="special">);</span>

<span class="comment">// [5.2.1.6] (complete) elliptic integral of the third kind:</span>
<span class="keyword">double</span> <span class="identifier">comp_ellint_3</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">k</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">nu</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">comp_ellint_3f</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">k</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">nu</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">comp_ellint_3l</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">k</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">nu</span><span class="special">);</span>

<span class="comment">// [5.2.1.7] confluent hypergeometric functions:</span>
<span class="keyword">double</span> <span class="identifier">conf_hyperg</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">c</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">conf_hypergf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">c</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">conf_hypergl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">c</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

<span class="comment">// [5.2.1.8] regular modified cylindrical Bessel functions:</span>
<span class="keyword">double</span> <span class="identifier">cyl_bessel_i</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">nu</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">cyl_bessel_if</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">nu</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">cyl_bessel_il</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">nu</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

<span class="comment">// [5.2.1.9] cylindrical Bessel functions (of the first kind):</span>
<span class="keyword">double</span> <span class="identifier">cyl_bessel_j</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">nu</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">cyl_bessel_jf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">nu</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">cyl_bessel_jl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">nu</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

<span class="comment">// [5.2.1.10] irregular modified cylindrical Bessel functions:</span>
<span class="keyword">double</span> <span class="identifier">cyl_bessel_k</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">nu</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">cyl_bessel_kf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">nu</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">cyl_bessel_kl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">nu</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

<span class="comment">// [5.2.1.11] cylindrical Neumann functions;</span>
<span class="comment">// cylindrical Bessel functions (of the second kind):</span>
<span class="keyword">double</span> <span class="identifier">cyl_neumann</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">nu</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">cyl_neumannf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">nu</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">cyl_neumannl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">nu</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

<span class="comment">// [5.2.1.12] (incomplete) elliptic integral of the first kind:</span>
<span class="keyword">double</span> <span class="identifier">ellint_1</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">k</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">phi</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">ellint_1f</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">k</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">phi</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">ellint_1l</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">k</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">phi</span><span class="special">);</span>

<span class="comment">// [5.2.1.13] (incomplete) elliptic integral of the second kind:</span>
<span class="keyword">double</span> <span class="identifier">ellint_2</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">k</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">phi</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">ellint_2f</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">k</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">phi</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">ellint_2l</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">k</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">phi</span><span class="special">);</span>

<span class="comment">// [5.2.1.14] (incomplete) elliptic integral of the third kind:</span>
<span class="keyword">double</span> <span class="identifier">ellint_3</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">k</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">nu</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">phi</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">ellint_3f</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">k</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">nu</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">phi</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">ellint_3l</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">k</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">nu</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">phi</span><span class="special">);</span>

<span class="comment">// [5.2.1.15] exponential integral:</span>
<span class="keyword">double</span> <span class="identifier">expint</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">expintf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">expintl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

<span class="comment">// [5.2.1.16] Hermite polynomials:</span>
<span class="keyword">double</span> <span class="identifier">hermite</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">hermitef</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">hermitel</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

<span class="comment">// [5.2.1.17] hypergeometric functions:</span>
<span class="keyword">double</span> <span class="identifier">hyperg</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">b</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">c</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">hypergf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">b</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">c</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">hypergl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">b</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">c</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

<span class="comment">// [5.2.1.18] Laguerre polynomials:</span>
<span class="keyword">double</span> <span class="identifier">laguerre</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">laguerref</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">laguerrel</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

<span class="comment">// [5.2.1.19] Legendre polynomials:</span>
<span class="keyword">double</span> <span class="identifier">legendre</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">l</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">legendref</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">l</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">legendrel</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">l</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

<span class="comment">// [5.2.1.20] Riemann zeta function:</span>
<span class="keyword">double</span> <span class="identifier">riemann_zeta</span><span class="special">(</span><span class="keyword">double</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">riemann_zetaf</span><span class="special">(</span><span class="keyword">float</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">riemann_zetal</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span><span class="special">);</span>

<span class="comment">// [5.2.1.21] spherical Bessel functions (of the first kind):</span>
<span class="keyword">double</span> <span class="identifier">sph_bessel</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">sph_besself</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">sph_bessell</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

<span class="comment">// [5.2.1.22] spherical associated Legendre functions:</span>
<span class="keyword">double</span> <span class="identifier">sph_legendre</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">l</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">m</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">theta</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">sph_legendref</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">l</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">m</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">theta</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">sph_legendrel</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">l</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">m</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">theta</span><span class="special">);</span>

<span class="comment">// [5.2.1.23] spherical Neumann functions;</span>
<span class="comment">// spherical Bessel functions (of the second kind):</span>
<span class="keyword">double</span> <span class="identifier">sph_neumann</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">sph_neumannf</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">sph_neumannl</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

<span class="special">}</span> <span class="comment">// namespace tr1</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre>
<p>
        <span class="bold"><strong>Standard Conformity:</strong></span> The following functions
        are not supported in the Boost version of this component:
      </p>
<pre class="programlisting"><span class="comment">// [5.2.1.7] confluent hypergeometric functions:</span>
<span class="keyword">double</span> <span class="identifier">conf_hyperg</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">c</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">conf_hypergf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">c</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">conf_hypergl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">c</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

<span class="comment">// [5.2.1.17] hypergeometric functions:</span>
<span class="keyword">double</span> <span class="identifier">hyperg</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">b</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">c</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">hypergf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">b</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">c</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">hypergl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">b</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">c</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_tr1.subject_list.c99_special"></a><a class="link" href="subject_list.html#boost_tr1.subject_list.c99_special" title="C99 Mathematical Special Functions.">C99 Mathematical
      Special Functions.</a>
</h3></div></div></div>
<p>
        The TR adds a number of special functions which were first introduced in
        the C99 standard to header &lt;cmath&gt;.
      </p>
<p>
        Refer to the <a href="../../../libs/math/doc/sf_and_dist/html/math_toolkit/main_overview/tr1.html" target="_top">Math
        Library docs</a> for more information.
      </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
<span class="keyword">namespace</span> <span class="identifier">tr1</span> <span class="special">{</span>

   <span class="comment">// types</span>
   <span class="keyword">typedef</span> <span class="identifier">floating</span><span class="special">-</span><span class="identifier">type</span> <span class="identifier">double_t</span><span class="special">;</span>
   <span class="keyword">typedef</span> <span class="identifier">floating</span><span class="special">-</span><span class="identifier">type</span> <span class="identifier">float_t</span><span class="special">;</span>

   <span class="comment">// functions</span>
   <span class="keyword">double</span> <span class="identifier">acosh</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">acoshf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">acoshl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">asinh</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">asinhf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">asinhl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">atanh</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">atanhf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">atanhl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">cbrt</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">cbrtf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">cbrtl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">copysign</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">copysignf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">y</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">copysignl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">erf</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">erff</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">erfl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">erfc</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">erfcf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">erfcl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">exp2</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">exp2f</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">exp2l</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">expm1</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">expm1f</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">expm1l</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">fdim</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">fdimf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">y</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">fdiml</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">fma</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">z</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">fmaf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">y</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">z</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">fmal</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">z</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">fmax</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">fmaxf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">y</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">fmaxl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">fmin</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">fminf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">y</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">fminl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">hypot</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">hypotf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">y</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">hypotl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">);</span>

   <span class="keyword">int</span> <span class="identifier">ilogb</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">int</span> <span class="identifier">ilogbf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">int</span> <span class="identifier">ilogbl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">lgamma</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">lgammaf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">lgammal</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

   <span class="keyword">long</span> <span class="keyword">long</span> <span class="identifier">llrint</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">long</span> <span class="identifier">llrintf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">long</span> <span class="identifier">llrintl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

   <span class="keyword">long</span> <span class="keyword">long</span> <span class="identifier">llround</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">long</span> <span class="identifier">llroundf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">long</span> <span class="identifier">llroundl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">log1p</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">log1pf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">log1pl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">log2</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">log2f</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">log2l</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">logb</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">logbf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">logbl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

   <span class="keyword">long</span> <span class="identifier">lrint</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="identifier">lrintf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="identifier">lrintl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

   <span class="keyword">long</span> <span class="identifier">lround</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="identifier">lroundf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="identifier">lroundl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">nan</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span> <span class="special">*</span><span class="identifier">str</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">nanf</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span> <span class="special">*</span><span class="identifier">str</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">nanl</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span> <span class="special">*</span><span class="identifier">str</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">nearbyint</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">nearbyintf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">nearbyintl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">nextafter</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">nextafterf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">y</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">nextafterl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">nexttoward</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">nexttowardf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">nexttowardl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">remainder</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">remainderf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">y</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">remainderl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">remquo</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">,</span> <span class="keyword">int</span> <span class="special">*</span><span class="identifier">pquo</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">remquof</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">y</span><span class="special">,</span> <span class="keyword">int</span> <span class="special">*</span><span class="identifier">pquo</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">remquol</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">,</span> <span class="keyword">int</span> <span class="special">*</span><span class="identifier">pquo</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">rint</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">rintf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">rintl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">round</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">roundf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">roundl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">scalbln</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">long</span> <span class="identifier">ex</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">scalblnf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">long</span> <span class="identifier">ex</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">scalblnl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">long</span> <span class="identifier">ex</span><span class="special">);</span>
   <span class="keyword">double</span> <span class="identifier">scalbn</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">ex</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">scalbnf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">ex</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">scalbnl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">ex</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">tgamma</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">tgammaf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">tgammal</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

   <span class="keyword">double</span> <span class="identifier">trunc</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">float</span> <span class="identifier">truncf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">truncl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

   <span class="comment">// C99 macros defined as C++ templates</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="identifier">signbit</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">int</span> <span class="identifier">fpclassify</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="identifier">isfinite</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="identifier">isinf</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="identifier">isnan</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="identifier">isnormal</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="identifier">isgreater</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">y</span><span class="special">);</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="identifier">isgreaterequal</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">y</span><span class="special">);</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="identifier">isless</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">y</span><span class="special">);</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="identifier">islessequal</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">y</span><span class="special">);</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="identifier">islessgreater</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">y</span><span class="special">);</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="identifier">isunordered</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">y</span><span class="special">);</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
        <span class="bold"><strong>Standard Conformity:</strong></span> The following functions
        are not supported in the Boost version of this component:
      </p>
<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">exp2</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">exp2f</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">exp2l</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

<span class="keyword">double</span> <span class="identifier">fdim</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">fdimf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">y</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">fdiml</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">);</span>

<span class="keyword">double</span> <span class="identifier">fma</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">z</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">fmaf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">y</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">z</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">fmal</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">z</span><span class="special">);</span>

<span class="keyword">int</span> <span class="identifier">ilogb</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">int</span> <span class="identifier">ilogbf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">int</span> <span class="identifier">ilogbl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

<span class="keyword">long</span> <span class="keyword">long</span> <span class="identifier">llrint</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">long</span> <span class="identifier">llrintf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">long</span> <span class="identifier">llrintl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

<span class="keyword">double</span> <span class="identifier">log2</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">log2f</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">log2l</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

<span class="keyword">double</span> <span class="identifier">logb</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">logbf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">logbl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

<span class="keyword">long</span> <span class="identifier">lrint</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">long</span> <span class="identifier">lrintf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">long</span> <span class="identifier">lrintl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

<span class="keyword">double</span> <span class="identifier">nan</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span> <span class="special">*</span><span class="identifier">str</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">nanf</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span> <span class="special">*</span><span class="identifier">str</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">nanl</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span> <span class="special">*</span><span class="identifier">str</span><span class="special">);</span>

<span class="keyword">double</span> <span class="identifier">nearbyint</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">nearbyintf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">nearbyintl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

<span class="keyword">double</span> <span class="identifier">remainder</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">remainderf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">y</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">remainderl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">);</span>

<span class="keyword">double</span> <span class="identifier">remquo</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">,</span> <span class="keyword">int</span> <span class="special">*</span><span class="identifier">pquo</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">remquof</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">y</span><span class="special">,</span> <span class="keyword">int</span> <span class="special">*</span><span class="identifier">pquo</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">remquol</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">,</span> <span class="keyword">int</span> <span class="special">*</span><span class="identifier">pquo</span><span class="special">);</span>

<span class="keyword">double</span> <span class="identifier">rint</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">rintf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">rintl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">);</span>

<span class="keyword">double</span> <span class="identifier">scalbln</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">long</span> <span class="identifier">ex</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">scalblnf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">long</span> <span class="identifier">ex</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">scalblnl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">long</span> <span class="identifier">ex</span><span class="special">);</span>
<span class="keyword">double</span> <span class="identifier">scalbn</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">ex</span><span class="special">);</span>
<span class="keyword">float</span> <span class="identifier">scalbnf</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">ex</span><span class="special">);</span>
<span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">scalbnl</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">ex</span><span class="special">);</span>

<span class="comment">// C99 macros defined as C++ templates</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="identifier">isgreater</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">y</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="identifier">isgreaterequal</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">y</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="identifier">isless</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">y</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="identifier">islessequal</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">y</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="identifier">islessgreater</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">y</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="identifier">isunordered</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">y</span><span class="special">);</span>
</pre>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2005 John Maddock<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="config.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../boost_tr1.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="header_list.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
